Web browsers are programs that serve as a front end to the World Wide Web on the Internet. In order to view a Web site, its address, i.e. Uniform Resource Locator (URL), is typed into the Web browser's location field and the home page of that Web site is downloaded to the Web browser. The home page is an index to other Web pages on that site that can be accessed by clicking a message or an icon on the home page. The home page is either received in a HyperText Markup Language (HTML) format or is converted to an HTML format by the Web browser for displaying to the user.
Some Web pages on the Internet make use of JavaServer Pages (JSP). JSP is an extension to the Java servlet technology that provides a simple programming vehicle for displaying dynamic content on a Web page. The JSP is an HTML Web page with embedded Java source code that is executed in the Web server or application server. The HTML provides the page layout that will be returned to the Web browser, and the Java provides the processing. For example, a JSP Web page may be used in which the HTML identifies the format of the Web page and the Java source code delivers a query to a database and fills in blank fields of the Web page with the results.
In order to create a Web page using JSP, the programmer simply writes the regular HTML in the normal manner, using whatever Web-page-building tools they normally use. The programmer then encloses the code for the dynamic parts in special tags, most of which start with “<%” and end with “%>”. For example, here is a section of a JSP page that results in something like    “Thanks for ordering Steve's Guide to JSP” for a URL of http://host/OrderConfirmation.jsp?title=Steve's+Guide+to+JSP:    Thanks for ordering    <I><%= request.getParameter (“title”) %></I>
Normally, the programmer gives the resulting file a “.jsp” extension, and typically installs it in any place a normal Web page may be installed. Although what is written typically looks more like a regular HTML file than a servlet, behind the scenes, the JSP page is converted to a servlet, with the static HTML simply being printed to the output stream associated with the servlet's service method. This is normally done the first time the page is requested.
Aside from the regular HTML, there are three main types of JSP constructs that may be embedded in a Web page: scripting elements, directives, and actions. Scripting elements let you specify Java code that will become part of the resultant servlet. Directives let you control the overall structure of the servlet. Actions let you specify existing components that should be used and otherwise control the behavior of the JSP engine. To simplify the scripting elements, programmers have access to a number of predefined variables such as “request” in the example above.
The standard JSP tags simplify JSP page development and maintenance. However, in order to obtain additional functionality, JSP technology also provides a mechanism for encapsulating other types of dynamic functionality in custom tags, which are extensions to the JSP language. Custom tags are usually distributed in the form of a tag library, which defines a set of related custom tags and contains the objects that implement the tags. Some examples of tasks that can be performed by custom tags include operations on implicit objects, processing forms, accessing databases and other enterprise services such as electronic mail and directories, and performing flow control. JSP tag libraries are created by developers who are proficient at the Java programming language and expert in accessing data and other services, and are used by Web application designers who can focus on presentation issues rather than being concerned with how to access enterprise services. As well as encouraging division of labor between library developers and library users, custom tags increase productivity by encapsulating recurring tasks so that they can be reused across more than one application.
With JSP Web pages, the Java Source code embedded therein is compiled into bytecode, e.g., into a servlet, when first encountered by the server. A servlet is a Web server that builds Web pages based on data that may be dynamic in nature. When a JSP page containing a custom tag is translated into a servlet, the tag is converted to operations on an object called a tag handler. The Web container, i.e. runtime environment, then invokes those operations when the JSP page's servlet is executed. The result is an HTML stream to the Web browser that contains the original HTML of the JSP Web page and the HTML generated by the servlet.
Thus, custom JSP tags, when compiled and executed by the server, generate raw HTML tags. With some Web pages, the customer JSP tags may be utilized to generate limited global JavaScript functions which along with the HTML provide a low-function view of “widgets” on the web page. A “widget” is a general term for a graphical user interface element, e.g., drop-down menu, dialog window, virtual push button, and other elements of a graphical user interface. Since custom JSP tags output raw HTML with only minimal global JavaScript functions, the developer of the Web page must resort to writing his/her own JavaScript to perform higher-level features and to achieve any inter-widget communication. Here, low-level features include, for example, simple rollover techniques and button click processing, whereas high-level features include those features that actually manipulate the data after the Web page is rendered, such as sorting table columns, updating the data presented in the view, and allowing for the connection of any widget event to any other widget action in any combination that meets the needs of the developer. Thus, it is not possible with known mechanisms to generate high-level functionality widgets in a JSP Web page based on the custom JSP tags contained within the JSP Web page. Known mechanisms provide the view only, which in actual practical usage tops out quickly and requires additional custom coding.
Therefore, it would be beneficial to have a system and method for generating high-function browser widgets with not only a view but also complete model and handler objects that allow for full addressability. Moreover, it would be beneficial to have a system and method by which custom JSP tags may be used to generate high-function widgets without requiring explicit JavaScript programming of those widgets in the code of the JSP Web page.